{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 稀疏数据和嵌入简介\n",
    "\n",
    "**学习目标：**\n",
    "* 将影评字符串数据转换为稀疏特征矢量\n",
    "* 使用稀疏特征矢量实现情感分析线性模型\n",
    "* 通过将数据投射到二维空间的嵌入来实现情感分析 DNN 模型\n",
    "* 将嵌入可视化，以便查看模型学到的词语之间的关系\n",
    "\n",
    "在此练习中，我们将探讨稀疏数据，并使用影评文本数据（来自 [ACL 2011 IMDB 数据集](http://ai.stanford.edu/~amaas/data/sentiment/)）进行嵌入。这些数据已被处理成 `tf.Example` 格式。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading data from https://download.mlcc.google.cn/mledu-datasets/sparse-data-embedding/train.tfrecord\n",
      "41631744/41625533 [==============================] - 121s 3us/step\n",
      "41639936/41625533 [==============================] - 121s 3us/step\n",
      "Downloading data from https://download.mlcc.google.cn/mledu-datasets/sparse-data-embedding/test.tfrecord\n",
      "40689664/40688441 [==============================] - 263s 6us/step\n",
      "40697856/40688441 [==============================] - 263s 6us/step\n"
     ]
    }
   ],
   "source": [
    "from __future__ import print_function\n",
    "\n",
    "import collections\n",
    "import io\n",
    "import math\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import tensorflow as tf\n",
    "from IPython import display\n",
    "from sklearn import metrics\n",
    "\n",
    "tf.logging.set_verbosity(tf.logging.ERROR)\n",
    "train_url = 'https://download.mlcc.google.cn/mledu-datasets/sparse-data-embedding/train.tfrecord'\n",
    "train_path = tf.keras.utils.get_file(train_url.split('/')[-1], train_url)\n",
    "test_url = 'https://download.mlcc.google.cn/mledu-datasets/sparse-data-embedding/test.tfrecord'\n",
    "test_path = tf.keras.utils.get_file(test_url.split('/')[-1], test_url)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def _parse_function(record):\n",
    "  \"\"\"Extracts features and labels.\n",
    "  \n",
    "  Args:\n",
    "    record: File path to a TFRecord file    \n",
    "  Returns:\n",
    "    A `tuple` `(labels, features)`:\n",
    "      features: A dict of tensors representing the features\n",
    "      labels: A tensor with the corresponding labels.\n",
    "  \"\"\"\n",
    "  features = {\n",
    "    \"terms\": tf.VarLenFeature(dtype=tf.string), # terms are strings of varying lengths\n",
    "    \"labels\": tf.FixedLenFeature(shape=[1], dtype=tf.float32) # labels are 0 or 1\n",
    "  }\n",
    "  \n",
    "  parsed_features = tf.parse_single_example(record, features)\n",
    "  \n",
    "  terms = parsed_features['terms'].values\n",
    "  labels = parsed_features['labels']\n",
    "\n",
    "  return  {'terms':terms}, labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<MapDataset shapes: ({terms: (?,)}, (1,)), types: ({terms: tf.string}, tf.float32)>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create the Dataset object.\n",
    "ds = tf.data.TFRecordDataset(train_path)\n",
    "# Map features and labels with the parse function.\n",
    "ds = ds.map(_parse_function)\n",
    "\n",
    "ds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "({'terms': array(['but', 'it', 'does', 'have', 'some', 'good', 'action', 'and', 'a',\n",
       "         'plot', 'that', 'is', 'somewhat', 'interesting', '.', 'nevsky',\n",
       "         'acts', 'like', 'a', 'body', 'builder', 'and', 'he', 'isn', \"'\",\n",
       "         't', 'all', 'that', 'attractive', ',', 'in', 'fact', ',', 'imo',\n",
       "         ',', 'he', 'is', 'ugly', '.', '(', 'his', 'acting', 'skills',\n",
       "         'lack', 'everything', '!', ')', 'sascha', 'is', 'played', 'very',\n",
       "         'well', 'by', 'joanna', 'pacula', ',', 'but', 'she', 'needed',\n",
       "         'more', 'lines', 'than', 'she', 'was', 'given', ',', 'her',\n",
       "         'character', 'needed', 'to', 'be', 'developed', '.', 'there',\n",
       "         'are', 'way', 'too', 'many', 'men', 'in', 'this', 'story', ',',\n",
       "         'there', 'is', 'zero', 'romance', ',', 'too', 'much', 'action',\n",
       "         ',', 'and', 'way', 'too', 'dumb', 'of', 'an', 'ending', '.', 'it',\n",
       "         'is', 'very', 'violent', '.', 'i', 'did', 'however', 'love', 'the',\n",
       "         'scenery', ',', 'this', 'movie', 'takes', 'you', 'all', 'over',\n",
       "         'the', 'world', ',', 'and', 'that', 'is', 'a', 'bonus', '.', 'i',\n",
       "         'also', 'liked', 'how', 'it', 'had', 'some', 'stuff', 'about',\n",
       "         'the', 'mafia', 'in', 'it', ',', 'not', 'too', 'much', 'or', 'too',\n",
       "         'little', ',', 'but', 'enough', 'that', 'it', 'got', 'my',\n",
       "         'attention', '.', 'the', 'actors', 'needed', 'to', 'be', 'more',\n",
       "         'handsome', '.', '.', '.', 'the', 'biggest', 'problem', 'i', 'had',\n",
       "         'was', 'that', 'nevsky', 'was', 'just', 'too', 'normal', ',',\n",
       "         'not', 'sexy', 'enough', '.', 'i', 'think', 'for', 'most', 'guys',\n",
       "         ',', 'sascha', 'will', 'be', 'hot', 'enough', ',', 'but', 'for',\n",
       "         'us', 'ladies', 'that', 'are', 'fans', 'of', 'action', ',',\n",
       "         'nevsky', 'just', 'doesn', \"'\", 't', 'cut', 'it', '.', 'overall',\n",
       "         ',', 'this', 'movie', 'was', 'fine', ',', 'i', 'didn', \"'\", 't',\n",
       "         'love', 'it', 'nor', 'did', 'i', 'hate', 'it', ',', 'just',\n",
       "         'found', 'it', 'to', 'be', 'another', 'normal', 'action', 'flick',\n",
       "         '.'], dtype=object)}, array([0.], dtype=float32))"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n = ds.make_one_shot_iterator().get_next()\n",
    "sess = tf.Session()\n",
    "sess.run(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create an input_fn that parses the tf.Examples from the given files,\n",
    "# and split them into features and targets.\n",
    "def _input_fn(input_filenames, num_epochs=None, shuffle=True):\n",
    "  \n",
    "  # Same code as above; create a dataset and map features and labels.\n",
    "  ds = tf.data.TFRecordDataset(input_filenames)\n",
    "  ds = ds.map(_parse_function)\n",
    "\n",
    "  if shuffle:\n",
    "    ds = ds.shuffle(10000)\n",
    "\n",
    "  # Our feature data is variable-length, so we pad and batch\n",
    "  # each field of the dataset structure to whatever size is necessary.     \n",
    "  ds = ds.padded_batch(25, ds.output_shapes)\n",
    "  \n",
    "  ds = ds.repeat(num_epochs)\n",
    "\n",
    "  \n",
    "  # Return the next batch of data.\n",
    "  features, labels = ds.make_one_shot_iterator().get_next()\n",
    "  return features, labels"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assignment 1:使用具有稀疏输入和显示词汇表的线性模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 50 informative terms that compose our model vocabulary. \n",
    "informative_terms = (\"bad\", \"great\", \"best\", \"worst\", \"fun\", \"beautiful\",\n",
    "                     \"excellent\", \"poor\", \"boring\", \"awful\", \"terrible\",\n",
    "                     \"definitely\", \"perfect\", \"liked\", \"worse\", \"waste\",\n",
    "                     \"entertaining\", \"loved\", \"unfortunately\", \"amazing\",\n",
    "                     \"enjoyed\", \"favorite\", \"horrible\", \"brilliant\", \"highly\",\n",
    "                     \"simple\", \"annoying\", \"today\", \"hilarious\", \"enjoyable\",\n",
    "                     \"dull\", \"fantastic\", \"poorly\", \"fails\", \"disappointing\",\n",
    "                     \"disappointment\", \"not\", \"him\", \"her\", \"good\", \"time\",\n",
    "                     \"?\", \".\", \"!\", \"movie\", \"film\", \"action\", \"comedy\",\n",
    "                     \"drama\", \"family\")\n",
    "\n",
    "terms_feature_column = tf.feature_column.categorical_column_with_vocabulary_list(key=\"terms\", vocabulary_list=informative_terms)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training set metrics:\n",
      "loss 11.368193\n",
      "accuracy_baseline 0.5\n",
      "global_step 1000\n",
      "recall 0.87296\n",
      "auc 0.8708339\n",
      "prediction/mean 0.53140575\n",
      "precision 0.7429194\n",
      "label/mean 0.5\n",
      "average_loss 0.4547277\n",
      "auc_precision_recall 0.86014557\n",
      "accuracy 0.78544\n",
      "---\n",
      "Test set metrics:\n",
      "loss 11.37368\n",
      "accuracy_baseline 0.5\n",
      "global_step 1000\n",
      "recall 0.8688\n",
      "auc 0.86912817\n",
      "prediction/mean 0.5294727\n",
      "precision 0.74195534\n",
      "label/mean 0.5\n",
      "average_loss 0.45494717\n",
      "auc_precision_recall 0.8570988\n",
      "accuracy 0.78332\n",
      "---\n"
     ]
    }
   ],
   "source": [
    "my_optimizer = tf.train.AdagradOptimizer(learning_rate=0.1)\n",
    "my_optimizer = tf.contrib.estimator.clip_gradients_by_norm(my_optimizer, 5.0)\n",
    "\n",
    "feature_columns = [ terms_feature_column ]\n",
    "\n",
    "\n",
    "classifier = tf.estimator.LinearClassifier(\n",
    "  feature_columns=feature_columns,\n",
    "  optimizer=my_optimizer,\n",
    ")\n",
    "\n",
    "classifier.train(\n",
    "  input_fn=lambda: _input_fn([train_path]),\n",
    "  steps=1000)\n",
    "\n",
    "evaluation_metrics = classifier.evaluate(\n",
    "  input_fn=lambda: _input_fn([train_path]),\n",
    "  steps=1000)\n",
    "print(\"Training set metrics:\")\n",
    "for m in evaluation_metrics:\n",
    "  print(m, evaluation_metrics[m])\n",
    "print(\"---\")\n",
    "\n",
    "evaluation_metrics = classifier.evaluate(\n",
    "  input_fn=lambda: _input_fn([test_path]),\n",
    "  steps=1000)\n",
    "\n",
    "print(\"Test set metrics:\")\n",
    "for m in evaluation_metrics:\n",
    "  print(m, evaluation_metrics[m])\n",
    "print(\"---\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assignment 2: 使用DNN网络"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training set metrics:\n",
      "loss 11.745952\n",
      "accuracy_baseline 0.52\n",
      "global_step 1000\n",
      "recall 1.0\n",
      "auc 0.903846\n",
      "prediction/mean 0.65126586\n",
      "precision 0.68421054\n",
      "label/mean 0.52\n",
      "average_loss 0.46983805\n",
      "auc_precision_recall 0.9272421\n",
      "accuracy 0.76\n",
      "---\n",
      "Test set metrics:\n",
      "loss 13.132556\n",
      "accuracy_baseline 0.52\n",
      "global_step 1000\n",
      "recall 0.9166667\n",
      "auc 0.81730765\n",
      "prediction/mean 0.5776635\n",
      "precision 0.6875\n",
      "label/mean 0.48\n",
      "average_loss 0.52530223\n",
      "auc_precision_recall 0.7794446\n",
      "accuracy 0.76\n",
      "---\n"
     ]
    }
   ],
   "source": [
    "##################### Here's what we changed ##################################\n",
    "classifier = tf.estimator.DNNClassifier(                                      #\n",
    "  feature_columns=[tf.feature_column.indicator_column(terms_feature_column)], #\n",
    "  hidden_units=[20,20],                                                       #\n",
    "  optimizer=my_optimizer,                                                     #\n",
    ")                                                                             #\n",
    "###############################################################################\n",
    "\n",
    "try:\n",
    "  classifier.train(\n",
    "    input_fn=lambda: _input_fn([train_path]),\n",
    "    steps=1000)\n",
    "\n",
    "  evaluation_metrics = classifier.evaluate(\n",
    "    input_fn=lambda: _input_fn([train_path]),\n",
    "    steps=1)\n",
    "  print(\"Training set metrics:\")\n",
    "  for m in evaluation_metrics:\n",
    "    print(m, evaluation_metrics[m])\n",
    "  print(\"---\")\n",
    "\n",
    "  evaluation_metrics = classifier.evaluate(\n",
    "    input_fn=lambda: _input_fn([test_path]),\n",
    "    steps=1)\n",
    "\n",
    "  print(\"Test set metrics:\")\n",
    "  for m in evaluation_metrics:\n",
    "    print(m, evaluation_metrics[m])\n",
    "  print(\"---\")\n",
    "except ValueError as err:\n",
    "  print(err)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assignment 3:在DNN模型中使用嵌入"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training set metrics:\n",
      "loss 11.548461\n",
      "accuracy_baseline 0.5\n",
      "global_step 1000\n",
      "recall 0.75912\n",
      "auc 0.86615825\n",
      "prediction/mean 0.47394434\n",
      "precision 0.7953898\n",
      "label/mean 0.5\n",
      "average_loss 0.46193844\n",
      "auc_precision_recall 0.8551895\n",
      "accuracy 0.78192\n",
      "---\n",
      "Test set metrics:\n",
      "loss 11.665424\n",
      "accuracy_baseline 0.5\n",
      "global_step 1000\n",
      "recall 0.74856\n",
      "auc 0.8637805\n",
      "prediction/mean 0.47332382\n",
      "precision 0.7929661\n",
      "label/mean 0.5\n",
      "average_loss 0.466617\n",
      "auc_precision_recall 0.85122293\n",
      "accuracy 0.77656\n",
      "---\n"
     ]
    }
   ],
   "source": [
    "########################## YOUR CODE HERE ######################################\n",
    "terms_embedding_column = tf.feature_column.embedding_column(terms_feature_column, dimension=2)# Define the embedding column\n",
    "feature_columns = [terms_embedding_column]# Define the feature columns\n",
    "\n",
    "my_optimizer = tf.train.AdagradOptimizer(learning_rate=0.1)\n",
    "my_optimizer = tf.contrib.estimator.clip_gradients_by_norm(my_optimizer, 5.0)\n",
    "\n",
    "classifier = tf.estimator.DNNClassifier(                                      #\n",
    "  feature_columns= feature_columns, #\n",
    "  hidden_units=[20,20],                                                       #\n",
    "  optimizer=my_optimizer,                                                     #\n",
    ")                    # Define the DNNClassifier\n",
    "################################################################################\n",
    "\n",
    "classifier.train(\n",
    "  input_fn=lambda: _input_fn([train_path]),\n",
    "  steps=1000)\n",
    "\n",
    "evaluation_metrics = classifier.evaluate(\n",
    "  input_fn=lambda: _input_fn([train_path]),\n",
    "  steps=1000)\n",
    "print(\"Training set metrics:\")\n",
    "for m in evaluation_metrics:\n",
    "  print(m, evaluation_metrics[m])\n",
    "print(\"---\")\n",
    "\n",
    "evaluation_metrics = classifier.evaluate(\n",
    "  input_fn=lambda: _input_fn([test_path]),\n",
    "  steps=1000)\n",
    "\n",
    "print(\"Test set metrics:\")\n",
    "for m in evaluation_metrics:\n",
    "  print(m, evaluation_metrics[m])\n",
    "print(\"---\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assignment 4：确信模型中确实存在嵌入"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['dnn/hiddenlayer_0/bias',\n",
       " 'dnn/hiddenlayer_0/bias/t_0/Adagrad',\n",
       " 'dnn/hiddenlayer_0/kernel',\n",
       " 'dnn/hiddenlayer_0/kernel/t_0/Adagrad',\n",
       " 'dnn/hiddenlayer_1/bias',\n",
       " 'dnn/hiddenlayer_1/bias/t_0/Adagrad',\n",
       " 'dnn/hiddenlayer_1/kernel',\n",
       " 'dnn/hiddenlayer_1/kernel/t_0/Adagrad',\n",
       " 'dnn/input_from_feature_columns/input_layer/terms_embedding/embedding_weights',\n",
       " 'dnn/input_from_feature_columns/input_layer/terms_embedding/embedding_weights/t_0/Adagrad',\n",
       " 'dnn/logits/bias',\n",
       " 'dnn/logits/bias/t_0/Adagrad',\n",
       " 'dnn/logits/kernel',\n",
       " 'dnn/logits/kernel/t_0/Adagrad',\n",
       " 'global_step']"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "classifier.get_variable_names()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(50, 2)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "classifier.get_variable_value('dnn/input_from_feature_columns/input_layer/terms_embedding/embedding_weights').shape\n",
    "#classifier.get_variable_value('dnn/input_from_feature_columns/input_layer/terms_embedding/embedding_weights/t_0/Adagrad').shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assignment 5：检查嵌入"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "embedding_matrix = classifier.get_variable_value('dnn/input_from_feature_columns/input_layer/terms_embedding/embedding_weights')\n",
    "\n",
    "for term_index in range(len(informative_terms)):\n",
    "  # Create a one-hot encoding for our term.  It has 0s everywhere, except for\n",
    "  # a single 1 in the coordinate that corresponds to that term.\n",
    "  term_vector = np.zeros(len(informative_terms))\n",
    "  term_vector[term_index] = 1\n",
    "  # We'll now project that one-hot vector into the embedding space.\n",
    "  embedding_xy = np.matmul(term_vector, embedding_matrix)\n",
    "  plt.text(embedding_xy[0],\n",
    "           embedding_xy[1],\n",
    "           informative_terms[term_index])\n",
    "\n",
    "# Do a little setup to make sure the plot displays nicely.\n",
    "plt.rcParams[\"figure.figsize\"] = (15, 15)\n",
    "plt.xlim(1.2 * embedding_matrix.min(), 1.2 * embedding_matrix.max())\n",
    "plt.ylim(1.2 * embedding_matrix.min(), 1.2 * embedding_matrix.max())\n",
    "plt.show() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training set metrics:\n",
      "loss 17.32223\n",
      "accuracy_baseline 0.5\n",
      "global_step 10\n",
      "recall 0.98\n",
      "auc 0.5386457\n",
      "prediction/mean 0.5151167\n",
      "precision 0.50287354\n",
      "label/mean 0.5\n",
      "average_loss 0.69288915\n",
      "auc_precision_recall 0.51065606\n",
      "accuracy 0.5056\n",
      "---\n",
      "Test set metrics:\n",
      "loss 17.319815\n",
      "accuracy_baseline 0.5\n",
      "global_step 10\n",
      "recall 0.98128\n",
      "auc 0.53905576\n",
      "prediction/mean 0.5151192\n",
      "precision 0.5042549\n",
      "label/mean 0.5\n",
      "average_loss 0.6927926\n",
      "auc_precision_recall 0.4728979\n",
      "accuracy 0.50828\n",
      "---\n"
     ]
    }
   ],
   "source": [
    "# Only train 10 steps\n",
    "########################## YOUR CODE HERE ######################################\n",
    "terms_embedding_column = tf.feature_column.embedding_column(terms_feature_column, dimension=2)# Define the embedding column\n",
    "feature_columns = [terms_embedding_column]# Define the feature columns\n",
    "\n",
    "my_optimizer = tf.train.AdagradOptimizer(learning_rate=0.1)\n",
    "my_optimizer = tf.contrib.estimator.clip_gradients_by_norm(my_optimizer, 5.0)\n",
    "\n",
    "classifier = tf.estimator.DNNClassifier(                                      #\n",
    "  feature_columns= feature_columns, #\n",
    "  hidden_units=[20,20],                                                       #\n",
    "  optimizer=my_optimizer,                                                     #\n",
    ")                    # Define the DNNClassifier\n",
    "################################################################################\n",
    "\n",
    "classifier.train(\n",
    "  input_fn=lambda: _input_fn([train_path]),\n",
    "  steps=10)\n",
    "\n",
    "evaluation_metrics = classifier.evaluate(\n",
    "  input_fn=lambda: _input_fn([train_path]),\n",
    "  steps=1000)\n",
    "print(\"Training set metrics:\")\n",
    "for m in evaluation_metrics:\n",
    "  print(m, evaluation_metrics[m])\n",
    "print(\"---\")\n",
    "\n",
    "evaluation_metrics = classifier.evaluate(\n",
    "  input_fn=lambda: _input_fn([test_path]),\n",
    "  steps=1000)\n",
    "\n",
    "print(\"Test set metrics:\")\n",
    "for m in evaluation_metrics:\n",
    "  print(m, evaluation_metrics[m])\n",
    "print(\"---\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "embedding_matrix = classifier.get_variable_value('dnn/input_from_feature_columns/input_layer/terms_embedding/embedding_weights')\n",
    "\n",
    "for term_index in range(len(informative_terms)):\n",
    "  # Create a one-hot encoding for our term.  It has 0s everywhere, except for\n",
    "  # a single 1 in the coordinate that corresponds to that term.\n",
    "  term_vector = np.zeros(len(informative_terms))\n",
    "  term_vector[term_index] = 1\n",
    "  # We'll now project that one-hot vector into the embedding space.\n",
    "  embedding_xy = np.matmul(term_vector, embedding_matrix)\n",
    "  plt.text(embedding_xy[0],\n",
    "           embedding_xy[1],\n",
    "           informative_terms[term_index])\n",
    "\n",
    "# Do a little setup to make sure the plot displays nicely.\n",
    "plt.rcParams[\"figure.figsize\"] = (15, 15)\n",
    "plt.xlim(1.2 * embedding_matrix.min(), 1.2 * embedding_matrix.max())\n",
    "plt.ylim(1.2 * embedding_matrix.min(), 1.2 * embedding_matrix.max())\n",
    "plt.show() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assignment 6:尝试改进模型的效果"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading data from https://download.mlcc.google.cn/mledu-datasets/sparse-data-embedding/terms.txt\n",
      "253952/253538 [==============================] - 1s 3us/step\n",
      "262144/253538 [===============================] - 1s 3us/step\n"
     ]
    }
   ],
   "source": [
    "# Download the vocabulary file.\n",
    "terms_url = 'https://download.mlcc.google.cn/mledu-datasets/sparse-data-embedding/terms.txt'\n",
    "terms_path = tf.keras.utils.get_file(terms_url.split('/')[-1], terms_url)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training set metrics:\n",
      "loss 9.905153\n",
      "accuracy_baseline 0.5\n",
      "global_step 1000\n",
      "recall 0.8568\n",
      "auc 0.9043714\n",
      "prediction/mean 0.5211776\n",
      "precision 0.8099524\n",
      "label/mean 0.5\n",
      "average_loss 0.39620614\n",
      "auc_precision_recall 0.9010698\n",
      "accuracy 0.82788\n",
      "---\n",
      "Test set metrics:\n",
      "loss 10.4729395\n",
      "accuracy_baseline 0.5\n",
      "global_step 1000\n",
      "recall 0.83472\n",
      "auc 0.8905474\n",
      "prediction/mean 0.51815635\n",
      "precision 0.79862225\n",
      "label/mean 0.5\n",
      "average_loss 0.41891757\n",
      "auc_precision_recall 0.88535297\n",
      "accuracy 0.81212\n",
      "---\n"
     ]
    }
   ],
   "source": [
    "# Create a feature column from \"terms\", using a full vocabulary file.\n",
    "informative_terms = None\n",
    "with io.open(terms_path, 'r', encoding='utf8') as f:\n",
    "  # Convert it to a set first to remove duplicates.\n",
    "  informative_terms = list(set(f.read().split()))\n",
    "  \n",
    "terms_feature_column = tf.feature_column.categorical_column_with_vocabulary_list(key=\"terms\", \n",
    "                                                                                 vocabulary_list=informative_terms)\n",
    "\n",
    "terms_embedding_column = tf.feature_column.embedding_column(terms_feature_column, dimension=2)\n",
    "feature_columns = [ terms_embedding_column ]\n",
    "\n",
    "my_optimizer = tf.train.AdagradOptimizer(learning_rate=0.1)\n",
    "my_optimizer = tf.contrib.estimator.clip_gradients_by_norm(my_optimizer, 5.0)\n",
    "\n",
    "classifier = tf.estimator.DNNClassifier(\n",
    "  feature_columns=feature_columns,\n",
    "  hidden_units=[10,10],\n",
    "  optimizer=my_optimizer\n",
    ")\n",
    "\n",
    "classifier.train(\n",
    "  input_fn=lambda: _input_fn([train_path]),\n",
    "  steps=1000)\n",
    "\n",
    "evaluation_metrics = classifier.evaluate(\n",
    "  input_fn=lambda: _input_fn([train_path]),\n",
    "  steps=1000)\n",
    "print(\"Training set metrics:\")\n",
    "for m in evaluation_metrics:\n",
    "  print(m, evaluation_metrics[m])\n",
    "print(\"---\")\n",
    "\n",
    "evaluation_metrics = classifier.evaluate(\n",
    "  input_fn=lambda: _input_fn([test_path]),\n",
    "  steps=1000)\n",
    "\n",
    "print(\"Test set metrics:\")\n",
    "for m in evaluation_metrics:\n",
    "  print(m, evaluation_metrics[m])\n",
    "print(\"---\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "embedding_matrix = classifier.get_variable_value('dnn/input_from_feature_columns/input_layer/terms_embedding/embedding_weights')\n",
    "\n",
    "for term_index in range(len(informative_terms)):\n",
    "  # Create a one-hot encoding for our term.  It has 0s everywhere, except for\n",
    "  # a single 1 in the coordinate that corresponds to that term.\n",
    "  term_vector = np.zeros(len(informative_terms))\n",
    "  term_vector[term_index] = 1\n",
    "  # We'll now project that one-hot vector into the embedding space.\n",
    "  embedding_xy = np.matmul(term_vector, embedding_matrix)\n",
    "  plt.text(embedding_xy[0],\n",
    "           embedding_xy[1],\n",
    "           informative_terms[term_index])\n",
    "\n",
    "# Do a little setup to make sure the plot displays nicely.\n",
    "plt.rcParams[\"figure.figsize\"] = (15, 15)\n",
    "plt.xlim(1.2 * embedding_matrix.min(), 1.2 * embedding_matrix.max())\n",
    "plt.ylim(1.2 * embedding_matrix.min(), 1.2 * embedding_matrix.max())\n",
    "plt.show() "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.15"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
